Mybatis框架（12） —— 实现数据库的CRUD操作（基于注解）

简介

• 如何使用映射配置文件的方式完成 CRUD 操作在前面已经详细的介绍过了，本文将通过使用注解的方式完成 CRUD 操作，并演示 Java实体类变量名 和 数据库字段名 相同和不相同的两种不同的处理方法。

目录结构

• src/main
  • java
    • cn/water/dao
      • UserDao.java（持久层接口）
      • User_UserDao.java（持久层接口）
    • cn/water/domain
      • User.java（实体层）
      • User_User.java（实体层）
    • resources
      • SqlMapConfig.xml（MyBatis主配置文件）
      • jdbcConfig.properties（数据库连接信息文件）
• src/tese
  • java
    • cn/water/test
      • UserTest.java（测试文件）
      • UserUserTest.java（测试文件）

MyBatis主配置文件

jdbcConfig.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis
jdbc.username=root
jdbc.password=root

SqlMapConfig.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">


        <!-- mybatis的主配置文件 -->
        <configuration>
    
            <!-- 外部配置 -->
            <properties resource="jdbcConfig.properties"></properties>

            <!-- 指定包：实体类-->
            <typeAliases>
                <package name="cn.water.domain"/>
            </typeAliases>

            <!-- 配置环境 -->
            <environments default="mysql">
                <environment id="mysql">
                    <transactionManager type="JDBC"></transactionManager>
                    <dataSource type="POOLED">
                        <!-- 配置连接数据库的4个基本信息 -->
                        <property name="driver" value="${jdbc.driver}"/>
                        <property name="url" value="${jdbc.url}"/>
                        <property name="username" value="${jdbc.username}"/>
                        <property name="password" value="${jdbc.password}"/>
                    </dataSource>
                </environment>
            </environments>

            <!-- 指定包：持久层接口 -->
            <mappers>
                <package name="cn.water.dao"/>
            </mappers>

        </configuration>

实体类

User.java

package cn.water.domain;

import java.io.Serializable;
import java.util.Date;

/**
 * @author Water
 * @date 2019/10/13 - 10:41
 * @description Java实体类的变量名 与 数据库的字段名 相同
 */
public class User implements Serializable {

    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", birthday=" + birthday +
                ", sex='" + sex + '\'' +
                ", address='" + address + '\'' +
                '}';
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

User_User.java

package cn.water.domain;

import java.io.Serializable;
import java.util.Date;

/**
 * @author Water
 * @date 2019/10/13 - 11:48
 * @description  Java实体类的变量名 与 数据库的字段名 不相同
 */
public class User_User implements Serializable {

    private Integer userId;
    private String userName;
    private Date userBirthday;
    private String userSex;
    private String userAddress;

    @Override
    public String toString() {
        return "User_User{" +
                "userId=" + userId +
                ", userName='" + userName + '\'' +
                ", userBirthday=" + userBirthday +
                ", userSex='" + userSex + '\'' +
                ", userAddress='" + userAddress + '\'' +
                '}';
    }

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public Date getUserBirthday() {
        return userBirthday;
    }

    public void setUserBirthday(Date userBirthday) {
        this.userBirthday = userBirthday;
    }

    public String getUserSex() {
        return userSex;
    }

    public void setUserSex(String userSex) {
        this.userSex = userSex;
    }

    public String getUserAddress() {
        return userAddress;
    }

    public void setUserAddress(String userAddress) {
        this.userAddress = userAddress;
    }
}

持久层接口

UserDao.java

package cn.water.dao;

import cn.water.domain.User;
import org.apache.ibatis.annotations.*;

import java.util.List;

/**
 * @author Water
 * @date 2019/10/12 - 16:43
 * @description Java实体类的变量名 与 数据库的字段名 相同
 */
public interface UserDao {

    /** 添加用户 */
    @Insert("INSERT INTO user VALUES(#{id},#{username},#{birthday},#{sex},#{address})")
    int add(User user);

    /** 更新用户 */
    @Update("update user set username=#{username},sex=#{sex},birthday=#{birthday},address=#{address} where id=#{id}")
    int update(User user);

    /** 删除用户 */
    @Delete("DELETE FROM user WHERE id = #{id}")
    int delete(Integer id);

    /** 查询所有用户 */
    @Select("SELECT * FROM user ")
    List<User> findAll();

    /** 查询单个用户 */
    @Select("SELECT * FROM user WHERE id = #{uid}")
    User findOne(Integer userId);

    /** 根据姓名模糊查询 */
    @Select("SELECT * FROM user WHERE username LIKE #{username}")
    List<User> findByName01(String name);

    @Select("SELECT COUNT(*) FROM user")
    /** 查询所有用户的数量 */
    Integer findTotal();


}

User_UserDao.java

package cn.water.dao;

import cn.water.domain.User;
import org.apache.ibatis.annotations.*;

import java.util.List;

/**
 * @author Water
 * @date 2019/10/13 - 11:50
 * @description 由于 Java实体类的变量名 与 数据库的字段名 不相同
 *              所以需要对 需要封装结果集的操作（查询操作） 进行设置
 */
public interface User_UserDao {

    /** 查询所有用户 */
    @Select("SELECT * FROM user ")
    @Results(id = "user_userMap",
            value = {
                @Result(id = true,column = "id",property = "userId"),
                @Result(id = true,column = "username",property = "userName"),
                @Result(id = true,column = "birthday",property = "userBirthday"),
                @Result(id = true,column = "sex",property = "userSex"),
                @Result(id = true,column = "address",property = "userAddress")
    })
    List<User> findAll();

    /** 查询用户，根据ID */
    @Select("SELECT * FROM user WHERE id=#{id}")
    @ResultMap("user_userMap")
    User findById(Integer id);

    /** 模糊查询，根据username */
    @Select("SELECT * FROM user WHERE username LIKE '%${value}%' ")
    @ResultMap("user_userMap")
    List<User> findByName(String username);



}

测试类

UserTest.java

package cn.water;

import cn.water.dao.UserDao;
import cn.water.domain.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.Date;

/**
 * @author Water
 * @date 2019/10/13 - 10:48
 * @description
 */
public class UserTest {

    private InputStream inputStream;
    private SqlSessionFactory factory;
    private SqlSession session;
    private UserDao dao;

    @Before
    public void init() throws IOException {
        inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        factory = new SqlSessionFactoryBuilder().build(inputStream);
        session = factory.openSession(true);
        dao = session.getMapper(UserDao.class);
    }

    @After
    public void destroy () throws IOException {
        session.close();
        inputStream.close();
    }

    /** 添加用户 */
    @Test
    public void test01(){
        User user = new User();
        user.setId(1);
        user.setUsername("mybatis anno add");
        user.setBirthday(new Date());
        user.setSex("男");
        user.setAddress("北京");
        System.out.println("受影响的行数："+dao.add(user));
    }

    /** 更新用户 */
    @Test
    public void test02(){
        User user = new User();
        user.setId(1);
        user.setUsername("mybatis anno update");
        user.setBirthday(new Date());
        user.setSex("男");
        user.setAddress("北京");

        System.out.println("受影响的行数："+dao.update(user));
    }

    /** 删除用户 */
    @Test
    public void test03(){
        System.out.println("受影响的行数："+dao.delete(1));
    }

    /** 查询所有用户 */
    @Test
    public void test04(){
        for (User user : dao.findAll()) {
            System.out.println(user);
        }
    }

    /** 查询用户，根据ID */
    @Test
    public void test05(){
        System.out.println(dao.findById(42));
    }

    /** 模糊查询，根据username */
    @Test
    public void test06(){
//        for (User user : dao.findByName("%王%")) {
        for (User user : dao.findByName("王")) {
            System.out.println(user);
        }
    }

    /** 查询用户数量 */
    @Test
    public void test07(){
        System.out.println(dao.findTotal());
    }


}

User_UserTest.java

package cn.water;

import cn.water.dao.UserDao;
import cn.water.domain.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.Date;

/**
 * @author Water
 * @date 2019/10/13 - 10:48
 * @description
 */
public class User_UserTest {

    private InputStream inputStream;
    private SqlSessionFactory factory;
    private SqlSession session;
    private UserDao dao;

    @Before
    public void init() throws IOException {
        inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        factory = new SqlSessionFactoryBuilder().build(inputStream);
        session = factory.openSession(true);
        dao = session.getMapper(UserDao.class);
    }

    @After
    public void destroy () throws IOException {
        session.close();
        inputStream.close();
    }

    /* 查询所用用户 */
    @Test
    public void test04(){
        for (User user : dao.findAll()) {
            System.out.println(user);
        }
    }

    /* 查询单个用户 */
    @Test
    public void test05(){
        System.out.println(dao.findById(42));
    }

    /* 模糊查询 */
    @Test
    public void test06(){
//        for (User user : dao.findByName("%王%")) {
        for (User user : dao.findByName("王")) {
            System.out.println(user);
        }
    }


}

实现CRUD操作

• 单表的CRUD操作是最基本的操作，前面我们的学习都是基于Mybaits的映射配置文件来实现的，现在我们试着使用基于MyBatis注解的方式来实现CRUD操作。
  • 本案例的情况是：Java实体类的变量名 与 数据库的字段名 相同
• 注解
  • @Insert：实现新增
  • @Update：实现更新
  • @Delete：实现删除
  • @Select：实现查询

添加用户

• 持久层接口

@Insert("INSERT INTO user VALUES (#{id},#{username},#{birthday},#{sex},#{address})")
int add (User user);

更新用户

• 持久层接口

@Update("UPDATE user SET username=#{username},birthday=#{birthday},sex=#{sex},address=#{address} WHERE id=#{id}")
int update (User user);

删除用户

• 持久层接口

@Delete("DELETE FROM user WHERE id=#{id}")
int delete (Integer id);

查找所有用户

• 持久层接口

@Select("SELECT * FROM user ")
List<User> findAll();

查询单个用户

• 持久层接口

@Select("SELECT * FROM user WHERE id=#{id}")
User findById(Integer id);

根据姓名模糊查询

• 持久层接口

//    @Select("SELECT * FROM user WHERE username LIKE #{username}")
    @Select("SELECT * FROM user WHERE username LIKE '%${value}%' ")
    List<User> findByName(String username);

查询所有用户数量

• 持久层接口

@Select("SELECT COUNT(*) FROM user ")
Integer findTotal();

实现查询操作

• 当 Java实体类的变量名 与 数据库的字段名 不相同时，我们需要设置 @Results注解。
• 注解
  • @Result：实现结果集封装
    • id：是否是主键字段
    • column：数据库的列名
    • property：需要装配的属性名
    • one：需要使用的@One注解（@Result（one=@One）（）））
    • many：需要使用的@Many注解（@Result（many=@many）（）））
  • @Results：封装多个结果集
  • @ResultMap：实现引用@Results定义的封装

查找所有用户

• 持久层接口

@Select("SELECT * FROM user ")
  @Results(id = "user_userMap",
          value = {
              @Result(id = true,column = "id",property = "userId"),
              @Result(id = true,column = "username",property = "userName"),
              @Result(id = true,column = "birthday",property = "userBirthday"),
              @Result(id = true,column = "sex",property = "userSex"),
              @Result(id = true,column = "address",property = "userAddress")
  })
  List<User> findAll();

查询单个用户

• 持久层接口

@Select("SELECT * FROM user WHERE id=#{id}")
   @ResultMap("user_userMap")
   User findById(Integer id);

根据姓名模糊查询

• 持久层接口

@Select("SELECT * FROM user WHERE username LIKE '%${value}%' ")
@ResultMap("user_userMap")
List<User> findByName(String username);